home *** CD-ROM | disk | FTP | other *** search
/ Tech Arsenal 1 / Tech Arsenal (Arsenal Computer).ISO / tek-01 / sox.zip / RAW.C < prev    next >
C/C++ Source or Header  |  1992-06-15  |  5KB  |  310 lines
  1. /*
  2.  * July 5, 1991
  3.  * Copyright 1991 Lance Norskog And Sundry Contributors
  4.  * This source code is freely redistributable and may be used for
  5.  * any purpose.  This copyright notice must be maintained. 
  6.  * Lance Norskog And Sundry Contributors are not responsible for 
  7.  * the consequences of using this software.
  8.  */
  9.  
  10. /*
  11.  * Sound Tools raw format file.
  12.  *
  13.  * Includes .ub, .uw, .sb, .sw, and .ul formats at end
  14.  */
  15.  
  16. /*
  17.  * Notes: most of the headerless formats set their handlers to raw
  18.  * in their startread/write routines.  
  19.  *
  20.  */
  21.  
  22. #include "st.h"
  23. #include "libst.h"
  24.  
  25. extern int summary, verbose;
  26.  
  27. rawstartread(ft) 
  28. ft_t ft;
  29. {
  30. }
  31.  
  32. rawstartwrite(ft) 
  33. ft_t ft;
  34. {
  35. }
  36.  
  37. rawread(ft, buf, nsamp) 
  38. ft_t ft;
  39. long *buf, nsamp;
  40. {
  41.     register long datum;
  42.     int abs;
  43.     int done = 0;
  44.  
  45.     char c;
  46.     unsigned char uc;
  47.     short s;
  48.     unsigned short us;
  49.     long l;
  50.     unsigned long ul;
  51.     float f;
  52.     double d;
  53.  
  54.     switch(ft->info.size) {
  55.         case BYTE: switch(ft->info.style) {
  56.             case SIGN2:
  57.                 while(done < nsamp) {
  58.                     datum = getc(ft->fp);
  59.                     if (feof(ft->fp))
  60.                         return done;
  61.                     /* scale signed up to long's range */
  62.                     *buf++ = LEFT(datum, 24);
  63.                     done++;
  64.                 }
  65.                 return done;
  66.             case UNSIGNED:
  67.                 while(done < nsamp) {
  68.                     datum = getc(ft->fp);
  69.                     if (feof(ft->fp))
  70.                         return done;
  71.                     /* Convert to signed */
  72.                     datum ^= 128;
  73.                     /* scale signed up to long's range */
  74.                     *buf++ = LEFT(datum, 24);
  75.                     done++;
  76.                 }
  77.                 return done;
  78.             case ULAW:
  79.                 /* grab table from Posk stuff */
  80.                 while(done < nsamp) {
  81.                     datum = getc(ft->fp);
  82.                     if (feof(ft->fp))
  83.                         return done;
  84.                     datum = st_ulaw_to_linear(datum);
  85.                     /* scale signed up to long's range */
  86.                     *buf++ = LEFT(datum, 16);
  87.                     done++;
  88.                 }
  89.                 return done;
  90.             case ALAW:
  91.                 fail("No A-Law support");
  92.                 return done;
  93.             }
  94.         case WORD: switch(ft->info.style) {
  95.             case SIGN2:
  96.                 while(done < nsamp) {
  97.                     datum = rshort(ft);
  98.                     if (feof(ft->fp))
  99.                         return done;
  100.                     /* scale signed up to long's range */
  101.                     *buf++ = LEFT(datum, 16);
  102.                     done++;
  103.                 }
  104.                 return done;
  105.             case UNSIGNED:
  106.                 while(done < nsamp) {
  107.                     datum = rshort(ft);
  108.                     if (feof(ft->fp))
  109.                         return done;
  110.                     /* Convert to signed */
  111.                     datum ^= 0x8000;
  112.                     /* scale signed up to long's range */
  113.                     *buf++ = LEFT(datum, 16);
  114.                     done++;
  115.                 }
  116.                 return done;
  117.             case ULAW:
  118.                 fail("No U-Law support for shorts");
  119.                 return done;
  120.             case ALAW:
  121.                 fail("No A-Law support");
  122.                 return done;
  123.             }
  124.         }
  125.     fail("Drop through in rawread!");
  126. }
  127.  
  128. void
  129. rawwrite(ft, buf, nsamp) 
  130. ft_t ft;
  131. long *buf, nsamp;
  132. {
  133.     register int datum;
  134.     int abs;
  135.     int done = 0;
  136.  
  137.     char c;
  138.     unsigned char uc;
  139.     short s;
  140.     unsigned short us;
  141.     long l;
  142.     unsigned long ul;
  143.     double d;
  144.     
  145.     switch(ft->info.size) {
  146.         case BYTE: switch(ft->info.style) {
  147.             case SIGN2:
  148.                 while(done < nsamp) {
  149.                     /* scale signed up to long's range */
  150.                     datum = RIGHT(*buf++, 24);
  151.                     putc(datum, ft->fp);
  152.                     done++;
  153.                 }
  154.                 return;
  155.             case UNSIGNED:
  156.                 while(done < nsamp) {
  157.                     /* scale signed up to long's range */
  158.                     datum = RIGHT(*buf++, 24);
  159.                     /* Convert to unsigned */
  160.                     datum ^= 128;
  161.                     putc(datum, ft->fp);
  162.                     done++;
  163.                 }
  164.                 return;
  165.             case ULAW:
  166.                 /* grab table from Posk stuff */
  167.                 while(done < nsamp) {
  168.                     /* scale signed up to long's range */
  169.                     datum = RIGHT(*buf++, 16);
  170.                     datum = st_linear_to_ulaw(datum);
  171.                     putc(datum, ft->fp);
  172.                     done++;
  173.                 }
  174.                 return;
  175.             case ALAW:
  176.                 fail("No A-Law support");
  177.                 return;
  178.             }
  179.         case WORD: switch(ft->info.style) {
  180.             case SIGN2:
  181.                 while(done < nsamp) {
  182.                     /* scale signed up to long's range */
  183.                     datum = RIGHT(*buf++, 16);
  184.                     wshort(ft, datum);
  185.                     done++;
  186.                 }
  187.                 return;
  188.             case UNSIGNED:
  189.                 while(done < nsamp) {
  190.                     /* scale signed up to long's range */
  191.                     datum = RIGHT(*buf++, 16);
  192.                     /* Convert to unsigned */
  193.                     datum ^= 0x8000;
  194.                     wshort(ft, datum);
  195.                     done++;
  196.                 }
  197.                 return;
  198.             case ULAW:
  199.                 fail("No U-Law support for shorts");
  200.                 return;
  201.             case ALAW:
  202.                 fail("No A-Law support");
  203.                 return;
  204.             }
  205.         }
  206.     /* My, there's a lot of code missing! */
  207.     fail("Drop through in rawwrite!");
  208. }
  209.  
  210.  
  211. /*
  212.  * Set parameters to the fixed parameters known for this format,
  213.  * and change format to raw format.
  214.  */
  215.  
  216. static  rawdefaults();
  217.  
  218. /* Signed byte */
  219. sbstartread(ft) 
  220. ft_t ft;
  221. {
  222.     ft->info.size = BYTE;
  223.     ft->info.style = SIGN2;
  224.     rawdefaults(ft);
  225. }
  226.  
  227. sbstartwrite(ft) 
  228. ft_t ft;
  229. {
  230.     ft->info.size = BYTE;
  231.     ft->info.style = SIGN2;
  232.     rawdefaults(ft);
  233. }
  234.  
  235. ubstartread(ft) 
  236. ft_t ft;
  237. {
  238.     ft->info.size = BYTE;
  239.     ft->info.style = UNSIGNED;
  240.     rawdefaults(ft);
  241. }
  242.  
  243. ubstartwrite(ft) 
  244. ft_t ft;
  245. {
  246.     ft->info.size = BYTE;
  247.     ft->info.style = UNSIGNED;
  248.     rawdefaults(ft);
  249. }
  250.  
  251. uwstartread(ft) 
  252. ft_t ft;
  253. {
  254.     ft->info.size = WORD;
  255.     ft->info.style = UNSIGNED;
  256.     rawdefaults(ft);
  257. }
  258.  
  259. uwstartwrite(ft) 
  260. ft_t ft;
  261. {
  262.     ft->info.size = WORD;
  263.     ft->info.style = UNSIGNED;
  264.     rawdefaults(ft);
  265. }
  266.  
  267. swstartread(ft) 
  268. ft_t ft;
  269. {
  270.     ft->info.size = WORD;
  271.     ft->info.style = SIGN2;
  272.     rawdefaults(ft);
  273. }
  274.  
  275. swstartwrite(ft) 
  276. ft_t ft;
  277. {
  278.     ft->info.size = WORD;
  279.     ft->info.style = SIGN2;
  280.     rawdefaults(ft);
  281. }
  282.  
  283. ulstartread(ft) 
  284. ft_t ft;
  285. {
  286.     ft->info.size = BYTE;
  287.     ft->info.style = ULAW;
  288.     rawdefaults(ft);
  289. }
  290.  
  291. ulstartwrite(ft) 
  292. ft_t ft;
  293. {
  294.     ft->info.size = BYTE;
  295.     ft->info.style = ULAW;
  296.     rawdefaults(ft);
  297. }
  298.  
  299. static
  300. rawdefaults(ft)
  301. ft_t ft;
  302. {
  303.     if (ft->info.rate == 0)
  304.         ft->info.rate = 8000;
  305.     if (ft->info.channels == -1);
  306.         ft->info.channels = 1;
  307. }
  308.  
  309.  
  310.